
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

:- consult(['mostrar', 'tests', 'solucion']).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% TESTING %%

% ACLARACION: se puede encontrar informacion sobre
% el el framework de testing usado en
% http://www.swi-prolog.org/pldoc/package/plunit.html
% Para correr los tests, ejecutar run_tests.

%%%%%% TESTING DIMENSION %%%%%%

:- begin_tests(dimension).
test(dimension1) :-
   dimension([[_]], 1, 1).

test(dimension2) :-
   dimension([[_,_]], 1, 2).

test(dimension3) :-
   dimension([[_], [_]], 2, 1).

test(dimension4) :-
   tablero1(T),
   dimension(T, 4, 4).

test(dimension5, [fail]) :-
   tablero1(T),
   dimension(T, 1, 1).

:- end_tests(dimension).



%%%%%% TESTING POSICION %%%%%%

:- begin_tests(posicion).
test(posicion1, [
   all(I == [0,0,0,1,1,1]),
   all(J == [0,1,2,0,1,2])
]) :-
   posicion([[1, 2, 3], [4, 5, 6]] , I , J).
:- end_tests(posicion).



%%%%%% TESTING SUBTABLERO %%%%%%

:- begin_tests(subtablero).
test(subtableroEjemploEjercicio) :-
   Tablero = [
              [ 1,  2,  3,  4],
              [ 5,  6,  7,  8],
              [ 9, 10, 11, 12],
              [13, 14, 15, 16]],
   subtablero(Tablero, 2, 1, Subtablero),
   Subtablero = [
                 [10, 11, 12],
                 [14, 15, 16]].

test(subtablero2) :-
   tablero1(T),
   subtablero(T, 0, 0, T).

test(subtablero3) :-
   tablero1(T),
   subtablero(T, 4, 4, []).

test(subtablero4, [fail]) :-
   tablero1(T),
   subtablero(T, 5, 5, _).
:- end_tests(subtablero).



%%%%%% TESTING TRANSPONER %%%%%%

:- begin_tests(transponer).
test(transponerEjemploEjercicio) :-
   Tablero = [
              [1, 2, 3],
              [4, 5, 6]],
   transponer(Tablero, Transpuesto),
   Transpuesto = [
                  [1, 4],
                  [2, 5],
                  [3, 6]].

test(transponer2) :-
   tablero1(T),
   transponer(T, [
                  [_, _, _, _],
                  [_, _, o, _],
                  [_, o, _, _],
                  [_, _, _, _]]).

test(transponer3) :-
   transponer([[1, 2, 3, 4]],
              [[1],
               [2],
               [3],
               [4]]).

test(transponer4) :-
   transponer([
               [1],
               [2],
               [3],
               [4]],
              [[1, 2, 3, 4]]).
:- end_tests(transponer).



%%%%%% TESTING ASIGNARPESO %%%%%%

:- begin_tests(asignarPeso).
test(asignarPesoEjemploEjercicio) :-
   Silueta = [
              [_, _, x],
              [_, x, x],
              [x, x, _]],
   asignarPeso(Silueta, 10, SiluetaConPeso),
   SiluetaConPeso = [
                     [ _,  _, 10],
                     [_, 10, 10],
                     [10, 10, _]].

test(asignarPeso2) :-
   asignarPeso([[3, V, x]], 1, [[1, V, 1]]).
:- end_tests(asignarPeso).



%%%%%% TESTING UBICARSILUETA %%%%%%

:- begin_tests(ubicarSilueta).
test(ubicarSiluetaEjemploEjercicio, [
   all(I == [0,0,1,2]),
   all(J == [1,2,2,0]),
   all(
      T == [
        [[_, x, x, _],
         [_, o, x, _],
         [_, _, o, _],
         [_, _, _, _]],

        [[_, _, x, x],
         [_, o, _, x],
         [_, _, o, _],
         [_, _, _, _]],

        [[_, _, _, _],
         [_, o, x, x],
         [_, _, o, x],
         [_, _, _, _]],

        [[_, _, _, _],
         [_, o, _, _],
         [x, x, o, _],
         [_, x, _, _]]
      ]
   )
]) :-
   tablero1(T),
   silueta1(S),
   ubicarSilueta(S, I , J, T).

test(ubicarSilueta2, [fail]) :-
   tablero2(T),
   SiluetaTe = [
                [x, x, x],
                [_, x, _]],
   ubicarSilueta(SiluetaTe, _ , _, T).

test(ubicarSilueta3, [fail]) :-
   silueta1(S),
   ubicarSilueta(S, _ , _, [[1,1],[1,1]]).

test(ubicarSilueta4, [fail]) :-
   silueta1(S),
   ubicarSilueta(S, _ , _, [[1],[1]]).

:- end_tests(ubicarSilueta).



%%%%%% TESTING UBICARPIEZA %%%%%%

:- begin_tests(ubicarPieza).
test(ubicarPiezaEjemploEjercicio, [
   all(I == [1,0,0]),
   all(J == [0,2,0]),
   all(
      T == [
        [[_, _, _, _],
         [0, 1, 2, _],
         [0, 3, 4, _],
         [0, 0, 5, _]],

        [[_, _, 0, 0],
         [_, 1, 2, 0],
         [_, 3, 4, 0],
         [_, _, 5, _]],

        [[0, 0, 0, _],
         [0, 1, 2, _],
         [_, 3, 4, _],
         [_, _, 5, _]]
      ]
   )
]) :-
   algunasPiezas(DiccPiezas),
   tablero2(T),
   ubicarPieza(ele , 0, DiccPiezas, I , J, T).

test(ubicarPieza2, [fail]) :-
   algunasPiezas(DiccPiezas),
   tablero2(Tablero),
   ubicarPieza(ese , 0, DiccPiezas, _ , _, Tablero).

test(ubicarPieza3, [fail]) :-
   algunasPiezas(DiccPiezas),
   Tablero = [
              [0, 0, 0],
              [0, 0, 0]],
   ubicarPieza(ese, 0, DiccPiezas, _, _, Tablero).
:- end_tests(ubicarPieza).



%%%%%% TESTING SOLUCIONVALIDA %%%%%%

:- begin_tests(solucionValida).
test(solucionValidaEjemploEjercicio,
   [all(Juego ==
      [juego([
             [1, 2, 3],
             [4, 5, 6]],
             [6, 15],
             [5, 7, 9])]),
   all(SumaColumna1 == [5])]
) :-
   Juego = juego([
                  [1, 2, 3],
                  [4, 5, 6]],
                  [6, 15],
                  [SumaColumna1, 7, _]),
   solucionValida(Juego).

test(solucionValida2, [fail]) :-
   Juego = juego([
                  [1, 2, 3],
                  [4, 5, 6]],
                  [10, _],
                  _),
   solucionValida(Juego).

test(solucionValida2, [fail]) :-
   Juego = juego([
                  [_, 2, 3],
                  [4, 5, 6]],
                  [6, 15],
                  [5, 7, 9]),
   solucionValida(Juego).

:- end_tests(solucionValida).



%%%%%% TESTING RESOLVER %%%%%%

:- begin_tests(resolver).
test(resolverEjemploEjercicio,
   all(
      Juego == [
         juego([
                [1, 2, 2, 7],
                [2, 2, 3, 3],
                [0, 1, 1, 3],
                [1, 1, 5, 3]],
                [12, 10, 5, 10],
                [4, 6, 11, 16]),

         juego([
                [1, 1, 1, 7],
                [1, 1, 3, 3],
                [0, 2, 2, 3],
                [2, 2, 5, 3]],
                [10, 8, 7, 12],
                [4, 6, 11, 16])
      ]
   )
) :-
   juego2(Juego),
   algunasPiezas(DiccPiezas),
   PiezasDisponibles = [pieza(ese , 2),
                        pieza(ele , 3),
                        pieza(ese , 1)],
   resolver(DiccPiezas, PiezasDisponibles, Juego).


% caso: complete el tablero y me quedan piezas por poner
test(resolver2, [fail]) :-
   juego2(Juego),
   algunasPiezas(DiccPiezas),
   PiezasDisponibles = [pieza(ele, 3),
                        pieza(ese , 2),
                        pieza(ele , 3),
                        pieza(ese , 1)],
   resolver(DiccPiezas, PiezasDisponibles , Juego).


% caso: ubique todas las piezas y el tablero quedo incompleto
test(resolver2, [fail]) :-
   juego2(Juego),
   algunasPiezas(DiccPiezas),
   PiezasDisponibles = [pieza(ele, 3)],
   resolver(DiccPiezas, PiezasDisponibles , Juego).


% caso: las piezas son todas cuadrados de peso 3 y llenan el tablero
test(resolver3, all(Juego == [
   juego([
          [3, 3, 3, 3],
          [3, 3, 3, 3]],
          [12, 12],
          [6, 6, 6, 6]),

   juego([
          [3, 3, 3, 3],
          [3, 3, 3, 3]],
          [12, 12],
          [6, 6, 6, 6])
])) :-
   Juego = juego([
                  [_, _, _, _],
                  [_, _, _, _]],
                  [12, 12],
                  [6, 6, 6, 6]),
   tetrominos(DiccPiezas),
   PiezasDisponibles = [pieza(cuadrado, 3),
                        pieza(cuadrado , 3)],
   resolver(DiccPiezas, PiezasDisponibles , Juego).


% caso: unica solucion (con las nuevas piezas):
test(resolver4, all(Juego == [
   juego([
          [2, 1, 0, 0, 0, 2, 4],
          [1, 1, 1, 0, 2, 2, 2],
          [0, 1, 0, 0, 0, 2, 0],
          [0, 0, 0, 0, 0, 0, 0],
          [0, 3, 0, 0, 0, 4, 0],
          [3, 3, 3, 0, 4, 4, 4],
          [8, 3, 0, 0, 0, 4, 16]],
          [9, 9, 3, 0, 7, 21, 31],
          [14, 12, 4, 0, 6, 18, 26])
])):-
   Juego = juego([
                  [_, _, 0, _, 0, _, _],
                  [_, _, _, _, _, _, _],
                  [0, _, 0, _, 0, _, 0],
                  [_, _, _, _, _, _, _],
                  [0, _, 0, _, 0, _, 0],
                  [_, _, _, _, _, _, _],
                  [_, _, 0, _, 0, _, _]],
                  [9, 9, 3, 0, 7, 21, 31],
                  [14, 12, 4, 0, 6, 18, 26]),
   nuevasPiezas(DiccPiezas),
   PiezasDisponibles = [
      pieza(cruzGrande, 0),
      pieza(cruzChica, 1),
      pieza(cruzChica, 2),
      pieza(cruzChica, 3),
      pieza(cruzChica, 4),
      pieza(cuadradoChico, 2),
      pieza(cuadradoChico, 4),
      pieza(cuadradoChico, 8),
      pieza(cuadradoChico, 16)],
   resolver(DiccPiezas, PiezasDisponibles , Juego).
:- end_tests(resolver).